from .video_service import VideoConfigProcessor
from datetime import datetime
import json
import os
import sys
from ..utils import logger
from typing import Dict, Any
from ..models import Project
from backend.sdk.script_file import Script_file
from .text_service import TextConfigProcessor, TextResponseBuilder
# 添加项目根目录到Python路径
current_dir = os.path.dirname(__file__)
project_root = os.path.dirname(os.path.dirname(os.path.dirname(current_dir)))
sys.path.insert(0, project_root)

# 剪映服务项目的核心类，用于创建复合项目模板


class JianYingTemplateService:
    """剪映项目模板服务类"""

    # Dict类型就是相当于Map<str,any>
    @staticmethod
    def create_template(user, template_data: Dict[str, Any]) -> Dict[str, Any]:
        try:
            # 解析画布配置 这里可以设置视频的宽高、帧率等参数
            canvas_config = JianYingTemplateService._parse_canvas_config(
                template_data)

            # 创建基础脚本 用于生成基本的模板结构，可以被剪映识别
            script: Script_file = JianYingTemplateService._create_base_script(
                canvas_config)

            # 处理各种配置 这个方法是主要的生成模板的逻辑 ，分为不同的情况添加模板片段
            processed_configs: Dict[str, Any] = JianYingTemplateService._process_configurations(
                script, template_data)

            # 生成模板内容
            template_content: Dict[str, Any] = JianYingTemplateService._generate_template_content(
                script)

            # 保存到数据库
            project: Any = JianYingTemplateService._save_to_database(
                user, template_content)

            # 构建响应
            response_data: Dict[str, Any] = JianYingTemplateService._build_response(
                project, canvas_config, processed_configs, template_content
            )

            logger.info(f"✅ 剪映项目模板创建成功: {project.name}")
            return response_data

        except Exception as e:
            logger.error(f"❌ 剪映项目模板创建失败: {str(e)}")
            raise

    # 接受画布的配置，并且返回标准的结构

    @staticmethod
    def _parse_canvas_config(template_data: Dict[str, Any]) -> Dict[str, int]:
        """解析画布配置"""
        canvas_config = template_data.get('canvas_config', {})
        return {
            'width': canvas_config.get('width', 1920),
            'height': canvas_config.get('height', 1080),
            'fps': canvas_config.get('fps', 30)
        }

    @staticmethod
    def _create_base_script(canvas_config: Dict[str, int]):
        """创建基础脚本对象"""
        from sdk.script_file import Script_file
        return Script_file(
            width=canvas_config['width'],
            height=canvas_config['height'],
            fps=canvas_config['fps']
        )

    # TODO 处理各种配置，包括文本、音频、视频等 主要的逻辑核心在这里
    @staticmethod
    def _process_configurations(script: Script_file, template_data: Dict[str, Any]) -> Dict[str, Any]:
        if script is None:
            raise ValueError("脚本对象不能为空，请检查画布配置是否正确")

        """处理各种配置"""
        processed_configs = {}

        # 1.处理文本配置 如果用户提供了文本配置，则创建文本片段
        text_conf = template_data.get('text_conf')
        if text_conf:
            logger.info("📝 检测到文本配置，开始处理文本片段")
            script = TextConfigProcessor.process(script, text_conf)
            processed_configs['text_conf'] = text_conf

        # 预留：处理视频配置
        video_conf = template_data.get('video_conf')
        if video_conf:
            logger.info("🎬 检测到视频配置，开始处理视频片段")
            processed_script = VideoConfigProcessor.process(script, video_conf)
            if processed_script is not None:
                script = processed_script
            processed_configs['video_conf'] = video_conf

        # 预留：处理音频配置
        audio_conf = template_data.get('audio_conf')
        if audio_conf:
            logger.info("🎵 检测到音频配置，开始处理音频片段")
            logger.warning("音频配置功能尚未实现")
            processed_configs['audio_conf'] = audio_conf

        if not any([text_conf, audio_conf, video_conf]):
            raise ValueError(
                "没有提供任何有效的配置，请至少提供文本、视频或音频配置"
            )

        return processed_configs

    @staticmethod
    def _generate_template_content(script: Script_file) -> Dict[str, Any]:
        """生成模板内容"""
        # 生成JSON模板并解析为对象
        json_template_str = script.dumps(parse_nested_json=False)
        json_template = json.loads(json_template_str)

        return {
            'json_string': json_template_str,
            'json_object': json_template
        }

    @staticmethod
    def _save_to_database(user, template_content: Dict[str, Any]) -> Project:
        """保存到数据库"""
        project = Project.objects.create(
            user=user,
            name=f'剪映模板_{datetime.now().strftime("%Y%m%d_%H%M%S")}',
            type='jianying-template',
            status='completed',
            draft_content=template_content['json_string']
        )
        project.refresh_from_db()
        return project

    # 构建标准的相应数据

    @staticmethod
    def _build_response(project: Project, canvas_config: Dict[str, int],
                        processed_configs: Dict[str, Any],
                        template_content: Dict[str, Any]) -> Dict[str, Any]:
        """构建响应数据"""
        project_info = {
            "id": project.pk,
            "name": project.name,
            "type": project.type,
            "canvas_config": canvas_config
        }

        # 如果处理了文本配置，添加文本信息到响应中
        if 'text_conf' in processed_configs:
            project_info["text_info"] = TextResponseBuilder.build_text_response_info(
                processed_configs['text_conf']
            )

        # 如果处理了视频配置，添加视频信息到响应中
        if 'video_conf' in processed_configs:
            project_info["video_info"] = VideoConfigProcessor.build_video_response_info(
                processed_configs['video_conf']
            )

        return {
            "success": True,
            "message": "剪映项目模板创建成功",
            "project_info": project_info,
            "template": template_content['json_object']
        }
